/*
 * TacticaHumberto.java
 *
 * Created on 28 de abril de 2007, 19:42
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package futbol.tacticas.concursantes2007.Loquehay;

import futbol.tacticas.concursantes.Tactica;

import java.awt.*;
import java.util.Vector;
import futbol.tacticas.*;

/**
 *
 * @author Humberto
 */
 
public class TacticaHumberto implements Tactica{
    
    private int nValores[][]={
        {-150,0,4},   //1
        {-115,15,4},   //2
        {-90,40,5},   //3 
        {-90,-40,5},  //4 
        {-20,0,4},    //5
        {-115,-15,5},    //6 
        {70,105,4},    //7
        {-20,50,4},   //8
        {70,-105,4},    //9
        {-20,-50,4},  //10
        {120,0,7}    //11
    };
    
    private int zonas [] = {
       // 1,2,3,4,5,6,7,8,9,10,11
        2,2,3,1,5,5,12,9,11,7,10
    };
    
    
    public String getNombre(){
        return "Lo que Hay";
    }
    
    public Color getColor1(){
        return Color.red;
    }
    
    public Color getColor2(){
        return Color.white;
    }
    
    public Color getColorNumero(){
        return Color.black;
    }
    
    public int getFuerza(int n){
        return nValores[n][2];
    }
    public int getXInicial(int n){
        return nValores[n][0];
    }
    
    public int getYInicial(int n){
        return nValores[n][1];
    }
    
    public Vector<Comando> getComandos(SituacionJugadores sj) {Vector<Comando> comandos=new Vector();
        Point mios[] = sj.getMisJugadores();
        Point bola = sj.getBola();
        
        for (int n=0;n<11;n++)
            if (!(estoyEnZona(sj,n))) 
            {comandos.add(new ComandoIrA(n, nValores[n][0], nValores[n][1]));}       

        moverArquero(sj,comandos);
        moverDefenza(sj, comandos);
        moverMediocampo(sj, comandos);
        moverAtaque(sj, comandos);
        
        int nJug=sj.getMasCercanoDeBola();
        if (nJug != 0)
            {comandos.add(new ComandoIrA(nJug,bola.getX(),bola.getY()));}
        return comandos;
    }
    
private void moverArquero(SituacionJugadores sj, Vector<Comando> comandos)
{
 Point jugadores [] = sj.getMisJugadores();
 Point contrarios [] = sj.getContrario();
 
 double posicionY = jugadores[0].getY();
 double bolaY = (sj.getBola().getY()/2);
        if (bolaY<-25) bolaY=-25;
        if (bolaY>25) bolaY=25;
 
 int contrarioMasCercaDeLaBola = (sj.getContrarioMasCerca(sj.getBola().getX(),sj.getBola().getY()));
 
 double miDistancia = distancia(sj.getBola().getX(),jugadores[0].getX(),sj.getBola().getY(),jugadores[0].getY());
 double suDistancia = distancia(sj.getBola().getX(),contrarios[contrarioMasCercaDeLaBola].getX(),sj.getBola().getY(),contrarios[contrarioMasCercaDeLaBola].getY());
 
 
 if (((sj.getBola().getX() < -129 ) & (sj.getBola().getY() < 36 ) & (sj.getBola().getY() > -36)) & (miDistancia < suDistancia))
    {comandos.add(new ComandoIrA(0,sj.getBola().getX(),bolaY));}
 
 else {comandos.add(new ComandoIrA(0, nValores[0][0],bolaY));}
 
 if( tengoElBalon(sj,0) ) 
    { if (posicionY >= 0)
        {comandos.add(new ComandoGolpearBola(0,100,-120));}
     else {comandos.add(new ComandoGolpearBola(0,100,120));}
    }
 else 
    {
     if ((0 == sj.getMasCercanoDeBola()) & (jugadorEstaDesmarcado(sj,0)) & (sj.getBola().getX() < -120))
     { comandos.add(new ComandoIrA(0,sj.getBola().getX(),sj.getBola().getY())); }
    }
} 
    
    private void moverAtaque(SituacionJugadores sj, Vector<Comando> comandos) {
        Point jugadores[]=sj.getMisJugadores();
        Point bola = sj.getBola();
        int desmarcado = -1;        // 7 9 11
                
        if ((sj.getBola().getX()) < 0) 
            {
            comandos.add(new ComandoIrA(6, nValores[6][0], nValores[6][1])); 
            comandos.add(new ComandoIrA(8, nValores[8][0], nValores[8][1])); 
            comandos.add(new ComandoIrA(10, nValores[10][0], nValores[10][1])); 
            }
        
        if (tengoElBalon(sj,6))
        {
        if (estoyEnPosicionDeTiro(sj,6))
            {comandos.add(new ComandoTiroAPuerta(6,13));} 
            else {if (estoyPorLaBanda(sj,6)) {
                    if (llegueAlFondo(sj,6)) {  centroPrimerPalo(sj,6,comandos);} 
                    else {  desbordoYacomodo(sj,6,comandos);}  } 
                  else { //ME FIJO SI TENGO A ALGUIEN ADELANTE DESMARCADO SI TENGO LA PASO SINO AVANZO
                  desmarcado = tengoDesmarcado(sj,6);
                        if (desmarcado == -1) {
                        avanzarAlArco(sj,6,30,comandos);} 
                        else { comandos.add(new ComandoPase(6,desmarcado));}
                       }
                }
         }
              else
        { if (laTieneElRival(sj)) 
            {if (bola.getX() > 90) 
                {comandos.add(new ComandoIrA(6, bola.getX(),bola.getY()));}
                }
             else{
              if (6 == sj.getMasCercanoDeBola())
                  {comandos.add(new ComandoIrA(6, bola.getX(),bola.getY()));}
              }
        }
        
        if (tengoElBalon(sj,8))
        {
            if (estoyEnPosicionDeTiro(sj,8)) {
                comandos.add(new ComandoTiroAPuerta(8,13));} 
            else{
                if (estoyPorLaBanda(sj,8)) 
                    {
                    if (llegueAlFondo(sj,8)) { centroPrimerPalo(sj,8,comandos);}
                    else {desbordoYacomodo(sj,8,comandos);}
                     }
               else
                    {
//ME FIJO SI TENGO A ALGUIEN ADELANTE DESMARCADO SI TENGO LA PASO SINO AVANZO
                    desmarcado = tengoDesmarcado(sj,8);
                    if (desmarcado == -1) 
                        { comandos.add(new ComandoGolpearBola(8, jugadores[8].getX()+10,jugadores[8].getY()));
                        comandos.add(new ComandoIrA(8, jugadores[8].getX()+10,jugadores[8].getY()));}
                    else
                        { comandos.add(new ComandoPase(8,desmarcado));}
                    }
                
                  }
         }
        
        
        else
        { if (laTieneElRival(sj)) 
            {if (bola.getX() > 90) 
                {comandos.add(new ComandoIrA(8, bola.getX(),bola.getY()));}
                }
             else{
              if (8 == sj.getMasCercanoDeBola())
                  {comandos.add(new ComandoIrA(8, bola.getX(),bola.getY()));}
             }
        }
        
//ACOMODAR VIENDO SI LA TIENE EL RIVAL O LA TENGO YO
        
//
        if( tengoElBalon(sj,10) ) {
            if (estoyEnPosicionDeTiro(sj,10)) {
                comandos.add(new ComandoTiroAPuerta(10,13));} 
            else {//ME FIJO SI TENGO A ALGUIEN ADELANTE DESMARCADO SI TENGO LA PASO SINO AVANZO 5
                desmarcado = tengoDesmarcado(sj,10);
                if (desmarcado == -1) 
                    {comandos.add(new ComandoGolpearBola(10, jugadores[10].getX()+20,jugadores[10].getY()));
                    comandos.add(new ComandoIrA(10, jugadores[10].getX()+20,jugadores[10].getY()));} 
                else {
                    comandos.add(new ComandoPase(10,desmarcado));}
                }
        } 
        else
        { if (laTieneElRival(sj)) 
            {if (bola.getX() > 90) 
                {comandos.add(new ComandoIrA(10, bola.getX(),bola.getY()));}
                }
             else{
              if (10 == sj.getMasCercanoDeBola())
                  {comandos.add(new ComandoIrA(10, bola.getX(),bola.getY()));}
                }
        }
    }
    
    
    private void moverMediocampo(SituacionJugadores sj, Vector<Comando> comandos) 
    {
        // 5 8 10
        
        if ((tengoElBalon(sj,4)) & (estoyEnPosicionDeTiro(sj,4)))
            {comandos.add(new ComandoTiroAPuerta(4,10));}
        if ((tengoElBalon(sj,7)) & (estoyEnPosicionDeTiro(sj,7)))
            {comandos.add(new ComandoTiroAPuerta(7,10));}
        if ((tengoElBalon(sj,9)) & (estoyEnPosicionDeTiro(sj,9)))
                {comandos.add(new ComandoTiroAPuerta(9,10));}
        
        if (tengoElBalon(sj,4))
            {actuarMedioCampo(sj,comandos,4);}
        if (tengoElBalon(sj,7))
            {actuarMedioCampo(sj,comandos,7);}
        if (tengoElBalon(sj,9))
                {actuarMedioCampo(sj,comandos,9);}
        
         if(laTieneElRival(sj))
          {hombreEnZona(sj,comandos,4);
           hombreEnZona(sj,comandos,7);
           hombreEnZona(sj,comandos,9);}
          else
          {if (laTengoYo(sj))
           {comandos.add(new ComandoIrA(4, sj.getBola().getX()-60,0));
           comandos.add(new ComandoIrA(7, sj.getBola().getX()-60,30));
           comandos.add(new ComandoIrA(9, sj.getBola().getX()-60,-30));}
           else 
           {int nJug=sj.getMasCercanoDeBola();
            if ((nJug == 4) | (nJug == 7) | (nJug == 9))
                {comandos.add(new ComandoIrA(nJug,sj.getBola().getX(),sj.getBola().getY()));}
            
                }
          }           
        
    }
    
    
    private void moverDefenza(SituacionJugadores sj, Vector<Comando> comandos) 
    {   
        if (tengoElBalon(sj,1))
            {actuarDefenza(sj,comandos,1);}
        if (tengoElBalon(sj,2))
            {actuarDefenza(sj,comandos,2);}
        if (tengoElBalon(sj,3))
            {actuarDefenza(sj,comandos,3);}
        if (tengoElBalon(sj,5))
            {actuarDefenza(sj,comandos,5);}
                
       if (sj.getBola().getX() < -10)
       { hombreEnZona (sj, comandos, 1);
         hombreEnZona (sj, comandos, 2);       
         hombreEnZona (sj, comandos, 3);
         hombreEnZona (sj, comandos, 5);    }
       else
       {comandos.add(new ComandoIrA(1, nValores[1][0], nValores[1][1]));
        comandos.add(new ComandoIrA(2, nValores[2][0], nValores[2][1]));
        comandos.add(new ComandoIrA(3, nValores[3][0], nValores[3][1]));
        comandos.add(new ComandoIrA(5, nValores[5][0], nValores[5][1]));  }
    }
    
    private boolean tengoElBalon(SituacionJugadores sj, int jugador) {
        Point jugadores [] = sj.getMisJugadores();
        Point bola = sj.getBola();
        double x1,x2,y1,y2 = 0;
        
        x1 = jugadores[jugador].getX();
        y1 = jugadores[jugador].getY();
        y2 = bola.getY();
        x2 = bola.getX();
        
        return (distancia(x1,x2,y1,y2) < 10);
    }
    
    private int tengoDesmarcado(SituacionJugadores sj, int jugador1) {
      Point jugadores[] = sj.getMisJugadores();
      Point contrarios[] = sj.getContrario();
      Point bola = sj.getBola();
        
      int nrojugadorAdelantado,nrojugadorContrario,contador,jugAdelantado = 0;    
      double distanciaMasCercano=9999999;
      int nroMasCercano = 0;
        
      int adelantados[] = new int [11];
        
      adelantados = delanteMio(sj,jugador1);
      if (adelantados[0]!=0)
        { contador = adelantados[0];
          while (contador > 0)
            {
            jugAdelantado = adelantados[contador];
            contador = contador -1;       
            nrojugadorContrario = sj.getContrarioMasCerca(jugAdelantado);
            Point jugadorAdelantado = jugadores[jugAdelantado];
            Point jugadorContrario = contrarios[nrojugadorContrario];
            if (distancia(jugadorAdelantado.getX(),jugadorContrario.getX(),jugadorAdelantado.getY(),jugadorContrario.getY()) > 20)
               {
                if (distancia(jugadores[jugador1].getX(),jugadores[jugAdelantado].getX(),jugadores[jugador1].getY(),jugadores[jugAdelantado].getY()) < distanciaMasCercano)
                    
                    {   distanciaMasCercano = distancia(jugadores[jugador1].getX(),jugadores[jugAdelantado].getX(),jugadores[jugador1].getY(),jugadores[jugAdelantado].getY());
                        nroMasCercano = jugAdelantado; }
                }            
            }
            if (distanciaMasCercano < 80){ return (nroMasCercano);}
            else {return (-1);}
        }
      else return (-1);
        
    }
    
    private boolean estoyEnPosicionDeTiro(SituacionJugadores sj, int jugador) 
    {
        Point jugadores[] = sj.getMisJugadores();
        double xActual = jugadores[jugador].getX();
        double yActual = jugadores[jugador].getY();
        
        if (jugador == 10) {return true;}
        else{
            if ((xActual > 95) & ((yActual < 30) & (yActual > -30)))
                {return true;}
            else
            { if (yActual >=0){ double y1 = (-0.5625 * xActual) + 120;
                    return (yActual < y1);}
                else { double y2 = (0.5625 * xActual) + 120;
                    return (yActual > y2);}
            }        
            }
    }
    
    private boolean estoyPorLaBanda(SituacionJugadores sj, int jugador)
    {
        Point jugadores[] = sj.getMisJugadores();
        return  (((Math.abs(jugadores[jugador].getY())) >= 50));    
    }
    
    private boolean llegueAlFondo(SituacionJugadores sj, int jugador) {
        Point jugadores[] = sj.getMisJugadores();
        return (jugadores[jugador].getX() >= 145);
        
    }
    
    private void desbordoYacomodo(SituacionJugadores sj, int jugador,Vector<Comando> comandos) {
        Point jugadores[] = sj.getMisJugadores();
        
        if (jugador == 6) {
            avanzarAlArco(sj,jugador,25,comandos);
            comandos.add(new ComandoIrA(10,125,5));
            comandos.add(new ComandoIrA(8,120,-20));
        } else  {
            avanzarAlArco(sj,jugador,25,comandos);
            comandos.add(new ComandoIrA(10,125,-5));
            comandos.add(new ComandoIrA(6,120,20));
            }
    }
    
    private void avanzarAlArco(SituacionJugadores sj, int jugador, double lugares,Vector<Comando> comandos) {
        Point jugadores[] = sj.getMisJugadores();
        double yActual = jugadores[jugador].getY();
        double posicionY = 0;
        
        if (yActual >=0)
        { posicionY = (yActual - Math.abs(yActual/9));}
        else
        { posicionY = (yActual + Math.abs(yActual/9));}

        if ((jugadores[jugador].getX() + lugares) > 155) {
            comandos.add(new ComandoGolpearBola(jugador, 155,posicionY ));
            comandos.add(new ComandoIrA(jugador, 155,posicionY ));} 
        else {
            comandos.add(new ComandoGolpearBola(jugador,(jugadores[jugador].getX() + lugares),posicionY ));
            comandos.add(new ComandoIrA(jugador, (jugadores[jugador].getX() + lugares),posicionY ));}
    }
    
    
 private void sortearRival(SituacionJugadores sj, int jugador,int rival, Vector<Comando> comandos) {
        Point jugadores[] = sj.getMisJugadores();
        Point rivales[] = sj.getContrario();
        
        double mioY = jugadores[jugador].getY();
        double mioX = jugadores[jugador].getX();
        double rivalY = jugadores[jugador].getY();
        double posicionY = 0;
        
        if (rivalY <= mioY)/*para abajo*/ 
            {
            if ((mioY + 30) < 120) 
                {comandos.add(new ComandoGolpearBola(jugador, mioX,mioY + 30 ));
                 comandos.add(new ComandoIrA(jugador, mioX,mioY + 30));}
            else
                {comandos.add(new ComandoTiroAPuerta(jugador,30 ));}
            }
         else /*para arriba*/ 
            {
            if ((mioY - 30) > -120)
                {comandos.add(new ComandoGolpearBola(jugador, mioX,mioY - 30 ));
                 comandos.add(new ComandoIrA(jugador, mioX,mioY - 30));}
            else
                {comandos.add(new ComandoTiroAPuerta(jugador,30 ));}
             }
 }
    

    private void centroPrimerPalo(SituacionJugadores sj, int jugador,Vector<Comando> comandos)
    {
     comandos.add(new ComandoPase(jugador,10));
    }
    
private boolean laTieneElRival(SituacionJugadores sj) {
      Point rivales [] = sj.getContrario();
      Point bola = sj.getBola();
      double x1,x2,y1,y2 = 0;
      boolean tiene = false;
      int i=0;
      
      y2 = bola.getY();
      x2 = bola.getX();
      while (!tiene & (i<=10))
      {
      x1 = rivales[i].getX();
      y1 = rivales[i].getY();
      tiene = (distancia(x1,x2,y1,y2) < 10);
      i++;
      } 
            
      return tiene;
    }


private boolean laTengoYo(SituacionJugadores sj) 
{
      Point jugadores [] = sj.getMisJugadores();
      Point bola = sj.getBola();
      double x1,x2,y1,y2 = 0;
      boolean tengo = false;
      int i=0;
      
      y2 = bola.getY();
      x2 = bola.getX();
      while (!tengo & (i<=10))
      {
      x1 = jugadores[i].getX();
      y1 = jugadores[i].getY();
      tengo = (distancia(x1,x2,y1,y2) < 10);
      i++;
      } 
            
      return tengo;
    }

private double distancia (double x1, double x2, double y1, double y2)
{
    return(Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2)));
}

private boolean jugadorEstaDesmarcado (SituacionJugadores sj,int nrojugador)
{
    Point mios [] = sj.getMisJugadores();
    Point rivales [] = sj.getContrario();
    int i = 0;
    double distancia=0;
    boolean ok = true;
    double jugadorX = mios[nrojugador].getX();
    double jugadorY = mios[nrojugador].getY();
    while ((i <= 10) & ok) {
        distancia = distancia (jugadorX,rivales[i].getX(),jugadorY,rivales[i].getY());
        if (distancia < 20) 
            {ok = false;}
    i++;
    }
    return (ok);
}

private boolean jugadorEstaDesmarcadoPorDelante (SituacionJugadores sj,int nrojugador)
{
    Point mios [] = sj.getMisJugadores();
    Point rivales [] = sj.getContrario();
    double jugadorX = mios[nrojugador].getX();
    double jugadorY = mios[nrojugador].getY();
    
    int i = 0;
    double distancia=0;
    boolean ok = true;
    
    while ((i <= 10) & ok) {
        if (jugadorX < rivales[i].getX())
        {
        distancia = distancia (jugadorX,rivales[i].getX(),jugadorY,rivales[i].getY());
        if (distancia < 40) 
            {ok = false;}
        }
    i++;}
    return (ok);
}
 
private boolean jugadorRivalEstaMarcado (SituacionJugadores sj,int nrojugador)
{
    Point mios [] = sj.getMisJugadores();
    Point rivales [] = sj.getContrario();
    int i = 0;
    double distancia=0;
    boolean ok = true;
    
    double rivalX = rivales[nrojugador].getX();
    double rivalY = rivales[nrojugador].getY();
    while ((i <= 10) & ok) {
        distancia = distancia (rivalX,mios[i].getX(),rivalY,mios[i].getY());
        if (distancia < 10) 
            {ok = false;}
    i++;
    }
    return (! ok);
}

private int[] rivalesCercanos( SituacionJugadores sj, int numerojugador, int rango)
{
    Point mios [] = sj.getMisJugadores();
    Point rivales [] = sj.getContrario();
    int i = 0;
    int rivalescercanos[] = new int[11];
    rivalescercanos[0] = 0;
    
    double miJugadorX = mios[numerojugador].getX();
    double miJugadorY = mios[numerojugador].getY();
    while (i <= 10) {
        if (distancia(miJugadorX,rivales[i].getX(),miJugadorY,rivales[i].getY()) < rango )
          { rivalescercanos[0] = rivalescercanos[0] + 1;
            rivalescercanos[rivalescercanos[0]] = i  ;
            ;}
        i++;
        }
    return (rivalescercanos);
     }

private int jugadorDesmarcadoMasCercano ( SituacionJugadores sj, int numerojugador, int rango)
{
    Point mios [] = sj.getMisJugadores();
    double jugadorX = mios[numerojugador].getX();
    double jugadorY = mios[numerojugador].getY();
    
    int cercanos[] = new int [11];
    double distancia = 999;
    int nrocercano = -1;

    cercanos = jugadoresCercanos(sj, numerojugador, rango);
    
    int longitud = cercanos[0];
    
    while (longitud > 0 ) 
        {
        int jugadorCercano = cercanos[longitud];
        if (this.jugadorEstaDesmarcado(sj,jugadorCercano))
        {  
           double cercanoX = mios[jugadorCercano].getX();
           double cercanoY = mios[jugadorCercano].getY();
           if (distancia(jugadorX,cercanoX,jugadorY,cercanoY) < distancia)
           {   distancia = distancia(jugadorX,cercanoX,jugadorY,cercanoY);
               nrocercano = jugadorCercano;           
           }      
        }
        longitud--;
        }
   return (nrocercano);
}

private int jugadorDesmarcadoMasCercanoAdelante ( SituacionJugadores sj, int numerojugador, int rango)
{
    Point mios [] = sj.getMisJugadores();
    double jugadorX = mios[numerojugador].getX();
    double jugadorY = mios[numerojugador].getY();
    
    int cercanos[] = new int [11];
    double distancia = 999999;
    int nrocercano = -1;

    cercanos = jugadoresCercanos(sj, numerojugador, rango);
    
    int longitud = cercanos[0];
    
    while (longitud > 0 ) 
        {
        int jugadorCercano = cercanos[longitud];
        if (this.jugadorEstaDesmarcado(sj,jugadorCercano))
        {  
           double cercanoX = mios[jugadorCercano].getX();
           double cercanoY = mios[jugadorCercano].getY();
           if (cercanoX >= jugadorX) {
           if (distancia(jugadorX,cercanoX,jugadorY,cercanoY) > distancia)
           {   distancia = distancia(jugadorX,cercanoX,jugadorY,cercanoY);
               nrocercano = jugadorCercano;           
           }      
           }
        }
        longitud--;
        }
   return (nrocercano);
}

private int[] jugadoresCercanos( SituacionJugadores sj, int numerojugador, int rango)
{
    Point mios [] = sj.getMisJugadores();
    double jugadorX = mios[numerojugador].getX();
    double jugadorY =  mios[numerojugador].getY();

    int cercanos[] = new int [11];
    cercanos[0]=0;
    int i = 0;
    
    while (i <= 10)
    {if (i != numerojugador)
        { if (distancia(jugadorX,mios[i].getX(),jugadorY,mios[i].getY()) <= rango )
          { cercanos[(cercanos[0] + 1)] = i;
            cercanos [0] = (cercanos [0] + 1);}
        }
    i++; }
    return cercanos;
}

private int jugadorRivalDesmarcadoMasCercano( SituacionJugadores sj, int numerojugador, int rango)
{
    Point mios [] = sj.getMisJugadores();
    Point rivales [] = sj.getContrario();
    int rivalescercanos[] = new int [10];
    int longitudrivales;    
    double distancia = 999;
    int nrorival = -1;
    int i = 1;
    
    rivalescercanos = rivalesCercanos(sj, numerojugador, rango/*, rivalescercanos, longitudrivales*/);
    longitudrivales = rivalescercanos[0];
            
    while (i <= longitudrivales)
    {
    if ( jugadorRivalEstaMarcado(sj,rivalescercanos[i]))     { }
     else {
         double jugadorX = mios[numerojugador].getX();
         double jugadorY = mios[numerojugador].getY();
         double rivalX = rivales[i].getX();
         double rivalY = rivales [i].getY();
         if (distancia > distancia(jugadorX,rivalX,jugadorY,rivalY))
            { distancia = distancia(jugadorX,rivalX,jugadorY,rivalY);
               nrorival = rivalescercanos[i];}
           }
    i++;}
    return (nrorival);
   }

private boolean estoyEnZona(SituacionJugadores sj,int numero)
{
    Point jugadores[] = sj.getMisJugadores();
    double jugX = jugadores[numero].getX();
    double jugY = jugadores[numero].getY();
    int zonaActual = calcularZona(jugX,jugY);
    return (zonas[numero] == zonaActual);
}

private int calcularZona(double x, double y)
{
   if (x >= 0) {
       if (x >=80)
         {  if (y <= -40) {return (10);}
            else {
                  if (y <= 40) {return (11);}
                  else {return (12);}
                 }
          }
       else 
        {  if (y <= -40) {return (7);}
            else {
                  if (y <= 40) {return (8);}
                  else {return (9);}
                 }
          }
                }///DEL IF PRINCIPAL X >=0
 else {
    if (x >= -80)
        {  if (y <= -40) {return (4);}
            else {
                  if (y <= 40) {return (5);}
                  else {return (6);}
                 }
          }
       else 
        {  if (y <= -40) {return (1);}
            else {
                  if (y <= 40) {return (2);}
                  else {return (3);}
                 }
          }
   }

}

private void hombreEnZona (SituacionJugadores sj, Vector<Comando> comandos, int numero)
{
    Point rivales[] = sj.getContrario();
    Point misJugadores[] = sj.getMisJugadores();
    double x,y;
    
    int mizona = zonas[numero];
    int nroRival = sj.getContrarioMasCerca(numero); //jugadorRivalDesmarcadoMasCercano(sj,numero,60);
    if (nroRival != -1) 
        {
        double rivalX = rivales[nroRival].getX();
        double rivalY = rivales[nroRival].getY();
        int zonaRival = calcularZona(rivalX,rivalY);
        if (mizona == zonaRival)
           {if (sj.getBola().getX() > misJugadores[numero].getX())
                {x = rivalX +20;}
            else
                {x = rivalX - 20;}
            if (sj.getBola().getY() > misJugadores[numero].getY())
                {y = rivalY +20;}
            else
                {y = rivalY - 20;}
            
            comandos.add(new ComandoIrA(numero, x, y));}
        }
}

private int [] delanteMio (SituacionJugadores sj, int numero)
{
    Point misJugadores[] = sj.getMisJugadores();
    int adelante[] = new int [11];
    adelante[0]=0;
    
    for (int i=0; i<=10; i++)
        {
        if (i != numero)  
            { if (misJugadores[i].getX() > misJugadores[numero].getX())
                  {adelante[0] = adelante[0]+1;
                   adelante [adelante[0]] = i;}
            }
        }
    return adelante;
}

private void actuarDefenza(SituacionJugadores sj, Vector<Comando> comandos, int jug)
{
    Point jugadores[]=sj.getMisJugadores();
    Point contrarios[] = sj.getContrario();
    Point bola = sj.getBola();    
    int desmarcado = -1;
    
    int contrarioAdelante = getContrarioMasCercanoAdelante(sj,jug,60);
    int contrarioAtras = getContrarioMasCercanoAtras(sj,jug,20);
    
    if ((contrarioAtras == -1) & (contrarioAdelante == -1))
        {avanzarAlArco(sj,jug,35,comandos);}
    else {
         if (contrarioAdelante == -1)
            {desmarcado = jugadorDesmarcadoMasCercanoAdelante(sj,jug,55);
             if (desmarcado != -1)
                {comandos.add(new ComandoPase(jug,desmarcado));}
             else {{avanzarAlArco(sj,jug,35,comandos);}}
            }
         else{buscarTrayectoriaDePase(sj,jug,comandos);}
         }
}

private void actuarMedioCampo(SituacionJugadores sj, Vector<Comando> comandos, int jug)
{   Point jugadores[]=sj.getMisJugadores();
    Point bola = sj.getBola();
    int desmarcado;
        desmarcado = tengoDesmarcado(sj,jug);
        if (desmarcado != -1) 
        {comandos.add(new ComandoPase(jug,desmarcado));}
        else 
        {gambetear(sj,comandos,jug);} 
}


private int getContrarioMasCercanoAdelante(SituacionJugadores sj, int jug,int rango)
{   Point contrarios[] = sj.getContrario();
    Point mios[] = sj.getMisJugadores();
    double miX = mios[jug].getX();
    double miY = mios[jug].getY();
    int i=0;
    int masCercano=-1;
    double distancia,distanciaMinima=999999;
    
    while (i < 11)
        {double Xrival = contrarios[i].getX();
         double Yrival = contrarios[i].getY();
         if (Xrival > miX) 
                {distancia = distancia(miX,Xrival,miY,Yrival);
                if ( (distancia < rango) & (distancia < distanciaMinima) )
                    { distanciaMinima = distancia;
                       masCercano = i;}
                }
    i++;}
    return masCercano;
}


private int getContrarioMasCercanoAtras(SituacionJugadores sj, int jug,int rango)
{
    Point contrarios[] = sj.getContrario();
    Point mios[] = sj.getMisJugadores();
    double miX = mios[jug].getX();
    double miY = mios[jug].getY();
    int i=0;
    int masCercano=-1;
    double distancia,distanciaMinima=999999;
    
    while (i < 11)
        {double Xrival = contrarios[i].getX();
         double Yrival = contrarios[i].getY();
         if (Xrival < miX) 
                {distancia = distancia(miX,Xrival,miY,Yrival);
                if ( (distancia < rango) & (distancia < distanciaMinima) )
                    { distanciaMinima = distancia;
                       masCercano = i;}
                }
    i++;}
    return masCercano;

}

private void buscarTrayectoriaDePase(SituacionJugadores sj, int jug, Vector<Comando> comandos)
{
    Point misjugadores[] = sj.getMisJugadores();
    int adelante[] = new int [11];
    boolean test = false;
    
    double xOrigen = misjugadores[jug].getX();
    double yOrigen = misjugadores[jug].getY();
    
    adelante = delanteMio(sj,jug);
    int longitud = adelante[0];
    while((longitud > 0) & (!test))
            { double xDestino = misjugadores[adelante[longitud]].getX();
              double yDestino = misjugadores[adelante[longitud]].getY();
              double m = (yOrigen - yDestino)/(xOrigen - xDestino);
              double b = (yOrigen-(xOrigen * m));
              double testX = xOrigen + 3;
              double testY = (testX * m) + b;
              test = verContrariosEnTrayecto(sj,testX,testY,5);
              while ( (testX < xDestino) & test)
                { testX = testX + 3;
                  testY = (testX * m) + b;
                  test = verContrariosEnTrayecto(sj,testX,testY,1);}
            longitud=longitud-1;
            }
    
    if (test) 
    {comandos.add(new ComandoPase(jug,adelante[longitud+1]));}             
    else   
    { gambetear(sj,comandos,jug);}
}

private boolean verContrariosEnTrayecto(SituacionJugadores sj,double testX, double testY, int rango)
{   Point contrarios[] = sj.getContrario();
    int i = 0;
    boolean ok=true;
    
    while ((i < 11) & ok)  
        {  if (distancia(contrarios[i].getX(),testX,contrarios[i].getY(),testY) < rango)
              {ok = false;}
        i++;}
    return ok;
}

private void gambetear (SituacionJugadores sj,Vector<Comando> comandos ,int numero)
{
    Point jugadores[] = sj.getMisJugadores();
    Point rivales[] = sj.getContrario();
    double mioX = jugadores[numero].getX();
    double mioY = jugadores[numero].getY();
    
    int rival = getContrarioMasCercanoAdelante(sj,numero,60);
    if (rival != -1)
    {
    double rivalX = rivales[rival].getX();
    double rivalY = rivales[rival].getY();
    
    if (distancia(mioX,rivalX,mioY,rivalY) < 40) {sortearRival(sj,numero,rival,comandos);}
   }
    else
        {comandos.add(new ComandoGolpearBola(numero, mioX + 30,mioY ));
         comandos.add(new ComandoIrA(numero, mioX + 30,mioY));}
}

}